Kinetic kd-trees

We propose a simple variant of kd-trees, called rankbased kd-trees, for sets of points in Rd. We show that a rank-based kd-tree, like an ordinary kd-tree, supports range search queries in O(n1-1/d + k) time, where k is the output size. The main advantage of rank-based kd-trees is that they can be efficiently kinetized: the KDS processes O(n2) events in the worst case, assuming that the points follow constantdegree algebraic trajectories, each event can be handled in O(log n) time, and each point is involved in O(1) certificates

Kinetic collision detection for balls rolling on a plane

This abstract presents a first step towards kinetic col- lision detection in 3 dimensions. In particular, we design a compact and responsive kinetic data struc- ture (KDS) for detecting collisions between n balls of arbitrary sizes rolling on a plane. The KDS has size O(n log n) and can handle events in O(log n) time. The structure processes O(n2) events in the worst case, assuming that the objects follow low-degree al- gebraic trajectories. The full paper [1] presents ad- ditional results for convex fat 3-dimensional objects that are free-flying in R3

Geodesic spanners for points on a polyhedral terrain

Let S be a set S of n points on a polyhedral terrain T in R3, and let " > 0 be a xed constant. We prove that S admits a (2 + ")-spanner with O(n log n) edges with respect to the geodesic distance. This is the rst spanner with constant spanning ratio and a near-linear number of edges for points on a terrain. On our way to this result, we prove that any set of n weighted points in Rd admits an additively weighted (2 + ")-spanner with O(n) edges; this improves the previously best known bound on the spanning ratio (which was 5 + "), and almost matches the lower bound

Streaming algorithms for line simplification under the Fréchet distance

We study the following variant of the well-known linesimplification problem: we are getting a possibly infinite sequence of points p0, p1, p2, . . . defining a polygonal path, and as we receive the points we wish to maintain a simplification of the path seen so far. We study this problem in a streaming setting, where we only have a limited amount of storage so that we cannot store all the points. We analyze the competitive ratio of our algorithm, allowing resource augmentation: we let our algorithm maintain a simplification with 2k (internal) points, and compare the error of our simplification to the error of the optimal simplification with k points

On the power of the semi-separated pair decomposition

A Semi-Separated Pair Decomposition (SSPD), with parameter s > 1, of a set is a set {(A i ,B i )} of pairs of subsets of S such that for each i, there are balls and containing A i and B i respectively such that min ( radius ) , radius ), and for any two points p, q S there is a unique index i such that p A i and q B i or vice-versa. In this paper, we use the SSPD to obtain the following results: First, we consider the construction of geometric t-spanners in the context of imprecise points and we prove that any set of n imprecise points, modeled as pairwise disjoint balls, admits a t-spanner with edges which can be computed in time. If all balls have the same radius, the number of edges reduces to . Secondly, for a set of n points in the plane, we design a query data structure for half-plane closest-pair queries that can be built in time using space and answers a query in time, for any ε> 0. By reducing the preprocessing time to and using space, the query can be answered in time. Moreover, we improve the preprocessing time of an existing axis-parallel rectangle closest-pair query data structure from quadratic to near-linear. Finally, we revisit some previously studied problems, namely spanners for complete k-partite graphs and l

New data structures and algorithms for mobile data

Recent advances in sensing and tracking technology have led researchers to investigate the problem of designing and analyzing algorithms and data structures for moving objects. One important issue in this area of research is which assumptions are made about the motions of the objects. The most common model is one where motions are assumed to be continuous and explicitly known in advance (or at least in the near future), usually as polynomial functions of time. The kinetic-data-structure framework introduced by Basch et al. is based on this model. It has become the common model for dealing with moving objects in computational geometry. A kinetic data structure (KDS) maintains a discrete attribute of a set of moving objects— the convex hull, for instance, or the closest pair. The basic idea is that although all objects move continuously there are only certain discrete moments in time when the combinatorial structure of the attribute—the ordered set of convex-hull vertices, or the pair that is closest—changes. A KDS contains a set of certificates that constitutes a proof that the maintained structure is correct. These certificates are inserted in a priority queue based on their time of expiration. The KDS then performs an event-driven simulation of the motion of the objects, updating the structure whenever an event happens, that is, when a certificate fails. In some applications, continuous tracking of a geometric attribute may be more than is needed; the attribute is only needed at certain times. This leads us to view a KDS as a query structure: we want to maintain a set S of moving objects in such a way that we can reconstruct the attribute of interest efficiently whenever this is called for. This makes it possible to reduce the maintenance cost, as it is no longer necessary to update the KDS whenever the attribute changes. On the other hand, a reduction in maintenance cost will have an impact on the query time, that is, the time needed to reconstruct the attribute. Thus there is a trade-off between maintenance cost and query time. In Chapter 2, we show a lower bound for the kinetic sorting problem showing the following: with a subquadratic maintenance cost one cannot obtain any significant speed-up on the time needed to generate the sorted list (compared to the trivial O(n log n) time), even for linear motions. This negative result gives a strong indication that good trade-offs are not possible for a large number of geometric problems—Voronoi diagrams and Delaunay triangulations, for example, or convex hulls—as the sorting problem can often be reduced to such problems. KDSs form a beautiful framework from a theoretical point of view, but whether or not they perform well in practice is unclear. A serious problem for the applicability of the KDS framework in practice is how to cope with the situation where event times cannot be computed exactly and events may be processed in a wrong order. We addresses this problem in Chapter 3. We present KDSs that are robust against the out-of-order processing, including kinetic sorting and kinetic tournaments. Our algorithms are quasi-robust in the sense that the maintained attribute of the moving objects will be correct for most of the time, and when it is incorrect, it will not be far from the correct attribute. The aim of the KDS framework is not only maintaining a uniquely defined geometric attribute but also maintaining a query data structure in order to quickly answer queries involving objects in motion such as "Which are the points currently inside a query rectangle?", or "What is currently the nearest point to a given query point?". In Chapter 4, we study the kinetic maintenance of kd-trees which are practical data structures to quickly report all points inside any given region. We present a new and simple variant of the standard kd-tree, called rank-based kd-trees, for a set of n points in d-dimensional space. Our rank-based kd-tree supports orthogonal range searching in time O(n1-1/d+k) and it uses O(n) storage—just like the original. But additionally it can be kinetized easily and efficiently. We obtain the similar results for longest-side kd-trees. Collision detection is a basic problem arising in all areas of geometric modeling involving objects in motion—motion planning, computer-simulated environments, or virtual prototyping, to name a few. Kinetic methods are naturally applicable to this problem. Although most applications of collision detection are more concerned with three dimensions than two dimensions, so far KDSs have been mostly developed for two-dimensional settings. In Chapter 5, we develop KDSs for 3D collision detection that have a near-linear number of certificates for multiple convex fat objects of varying sizes and for a special case of balls rolling on a plane. In a practical setting, the object motion may not known exactly or the explicit description of the motion may be unknown in advance. For instance, suppose we are tracking one, or maybe many, moving objects. Each object is equipped with a device that is transmitting its position at certain times. Then, we just have access to some sample points of the object path instead of the whole path, and an explicit motion description is unavailable. Thus, we are just receiving a stream of data points that describes the path along which the object moves. This model is the subject of Chapter 6. Here, we present the first general algorithm for maintaining a simplification of the trajectory of a moving object in this model, without using too much storage. We analyze the competitive ratio of our algorithms, allowing resource augmentation: we let our algorithm maintain a simplification with 2k (internal) points, and compare the error of our simplification to the error of the optimal simplification with k points

An approximation algorithm for d1d_1-optimal motion of a rod robot with fixed rotations

Given a translating and rotating rod robot in a plane in the presence of polygonal obstacles with the initial and final placements of the rod known, the d1-optimal motion planning problem is defined as finding a collision-free motion of the rod such that the orbit length of a fixed but arbitrary point F on the rod is minimized. In this paper we study a special case of this problem in which the rod can translate freely, but can only rotate by some pre-specified given angles around F. We first characterize the d1-optimal motion of the robot under the given conditions and then present a (1 + e)-approximation algorithm for finding the optimal path. The running time of the algorithm is bounded by a polynomial in terms of some parameters related to the problem input

Kinetic spanners in Rd

We present a new $(1 + \epsilon)$-spanner for sets of $n$ points in $\mathbb{R}^d$. Our spanner has size $O(n/\epsilon^{d-1})$ and maximum degree $O(\log^d n)$. The main advantage of our spanner is that it can be maintained efficiently as the points move: Assuming that the trajectories of the points can be described by bounded-degree polynomials, the number of topological changes to the spanner is $O(n^2/\epsilon^{d-1})$, and using a supporting data structure of size $O(n\log^d n)$, we can handle events in time $O(\log^{d+1} n)$. Moreover, the spanner can be updated in time $O(\log n)$ if the flight plan of a point changes. This is the first kinetic spanner for points in $\mathbb{R}^d$ whose performance does not depend on the spread of the point set